#include "nfc_ctrl.h"
#include "string.h"
#include "adc2_rte.h"
#include "key.h"
#include "ver_comp.h"
static NFCCTRL_test nfcctrl_test;
static union DataUnion data;
Rt_result NFCCTRL_hard_soft(void);
Rt_result NFCCTRL_Out_test(void);
Rt_result NFCCTRL_input_test(void);
Rt_result NFCCTRL_uartcom_test(void);
Rt_result NFCCTRL_stopEHBL_powerout(void);
Rt_result canrsp_Left_led(void);
Rt_result canrsp_emer_led(void);
Rt_result canrsp_IGN(void);
Rt_result canrsp_right_led(void);
Rt_result canrsp_brake_led(void);

static AppServer_NFCCTRL_Fun NFCCTRL_List[NFC_CTRL_MAX] =
    {
        {NFCCTRL_hard_soft},
        {NFCCTRL_Out_test},
        {NFCCTRL_input_test},
        {NFCCTRL_uartcom_test},
        {NFCCTRL_stopEHBL_powerout},
        {NFCCTRL_low_power}};
static AppServer_NFCCTRL_input_canrsp NFCCTRL_canrsp_List[5] =
    {
        {canrsp_Left_led},
        {canrsp_emer_led},
        {canrsp_IGN},
        {canrsp_right_led},
        {canrsp_brake_led}};

static uint8_t can_com_data[8] = {0x22, 0xF1, 0x93, 0x00, 0x00, 0x00, 0x00, 0x00};     /*can软硬件版本请求*/
static uint8_t can_out_pin[8] = {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};      /*can输出测试*/
static uint8_t can_input_pin_rq[8] = {0x31, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00}; /*can输入请求测试*/
// static uint8_t can_input_pin_rsp[8] = {0x31, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; /*can输入回复测试*/
static uint8_t can_stop_ehbl[8] = {0x31, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00}; /*禁止EHBL电源输出测试*/
static uint8_t can_low_power[8] = {0x31, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00}; /*低功耗检测*/
/*
 * 函数介绍: NFC控制器CAN接受回调函数
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void NFCCTRL_can_cbk(uint16_t id, uint8_t data[])
{
    if (CAN_CTRL_ID == id && OK_SENT_OR_RECEIVED == nfcctrl_test.cantx_flag)
    {
        nfcctrl_test.cantx_flag = NO_SENT_OR_RECEIVED; /*清除各阶段CAN发送成功标志*/
        nfcctrl_test.canrx_flag = OK_SENT_OR_RECEIVED; /*写入各阶段CAN接受成功标志*/
        memcpy(nfcctrl_test.canrx.can_data, data, 8);  /*填入接受data*/
    }
    else
    {
    }
}

/*
 * 函数介绍: NFC控制器uart接受回调函数
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void NFCCTRL_uart_cbk(uint16_t cmd, uint8_t data[])
{
    if (nfcctrl_test.uarttx.sig.CMD == cmd && OK_SENT_OR_RECEIVED == nfcctrl_test.uarttx_flag)
    {
        nfcctrl_test.uarttx_flag = NO_SENT_OR_RECEIVED;                                            /*清除各阶段CAN发送成功标志*/
        nfcctrl_test.uartrx_flag = OK_SENT_OR_RECEIVED;                                            /*写入各阶段CAN接受成功标志*/
        memcpy((void *)nfcctrl_test.uartrx.L_data[2], data, sizeof(nfcctrl_test.uartrx.sig.DATA)); /*填入接受data*/
    }
    else
    {
    }
}

/*
 * 函数介绍: NFC控制器应用层初始化
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void NFCCTRL_init(void)
{
    uint8_t i;
    nfcctrl_test.stage = NFC_CTRL_MAX;
    for (i = 0; i < NFC_CTRL_MAX; i++)
    {
        nfcctrl_test.e_sta[i] = TEST_WAIT;
    }
    nfcctrl_test.CTRL_ver_comp = TEST_WAIT;
    nfcctrl_test.CTRL_results = TEST_WAIT;
    nfcctrl_test.cantx_flag = NO_SENT_OR_RECEIVED;
    nfcctrl_test.canrx_flag = NO_SENT_OR_RECEIVED;
    nfcctrl_test.uarttx_flag = NO_SENT_OR_RECEIVED;
    nfcctrl_test.uartrx_flag = NO_SENT_OR_RECEIVED;
    nfcctrl_test.N_flag.NFCCTRL_send_data_only = false;  /*初始化CTRL通讯输入检测,只发送一次请求标志位*/
    nfcctrl_test.N_flag.NFCCTRL_lowpro_del_flag = false; /**/
    nfcctrl_test.N_flag.outpin_flag = OUT_MIN;           /*初始化CTRL通讯输出检测阶段标志*/
    nfcctrl_test.N_flag.inputpin_flag = IN_MIN;          /*初始化CTRL通讯输入检测阶段标志*/
    nfcctrl_test.N_flag.v_stage = HARDWARE_VERSION;      /*初始化CTRL串口通讯软硬件标志*/
    nfcctrl_test.N_flag.Error_record = 0;                /*初始化CTRL串口通讯软硬件错误计数*/
}

/*
 * 函数介绍: NFC控制器CAN通讯测试计算发送给LCD的软硬件版本号
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result NFCCTRL_rtlcd_can_swhd(Byte0Status St, NFCTestStatus Status, uint8_t candata[])
{
    uint8_t i;
    Rt_result result = TEST_WAIT;
    uint32_t Software_version; /*发送给LCD的软件版本号*/
    uint32_t Hardware_version; /*发送给LCD的硬件版本号*/
    memcpy(data.bytes, candata, 8);
    if (STATUS_QUALIFIED == St)
    {
        // 将字节转换为ASCII字符并存储到字符串中
        for (i = 0; i < 8; i++)
        {
            data.bytes[i] = data.bytes[i] - '0';
        }
    }
#if 0
    if (CONTROLLER == rt_Curr_produ())
    {
        if (0x02 == data.bytes[2])
        {
            data.bytes[2] = 0x04;
        }
    }
#endif
    Software_version = data.value >> 32;
    Hardware_version = data.value;
    RTE_UART7_LCD_SHOW(Status, LCD_SOFTWARE_VERSION, Software_version); /*LCD通过CMD分别显示在软件版本位置上*/
    RTE_UART7_LCD_SHOW(Status, LCD_HARDWARE_VERSION, Hardware_version); /*LCD通过CMD分别显示在硬件版本位置上*/
    result = Version_number_comparison(Status, St, HARDWARE_VERSION_NUMBER_CORRECT, data.bytes);
    result = Version_number_comparison(Status, St, SOFTWARE_VERSION_NUMBER_CORRECT, &data.bytes[4]);
    return result;
}

/*
 * 函数介绍: NFC控制器通讯测试软硬件版本号
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result NFCCTRL_hard_soft(void)
{
    Rt_result result = TEST_WAIT;
    static uint32_t Record_send_time = 0;                                  /*记录_发送_时间*/
    uint8_t candata[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; /*can软硬件失败版本号*/
    /*只发送一次闭锁请求*/
    if (false == nfcctrl_test.N_flag.NFCCTRL_send_data_only)
    {
        nfcctrl_test.cantx.can_id = CAN_FUN_ADDR;                                /*填入发送ID*/
        memcpy(nfcctrl_test.cantx.can_data, can_com_data, sizeof(can_com_data)); /*填入发送data*/
        nfcctrl_test.N_flag.NFCCTRL_send_data_only = true;
        for (uint8_t i = 0; i < 4; i++)
        {
            RTE_HAL_DELAY(50);
            RTE_CAN_TRANSMIT(nfcctrl_test.cantx.can_id, nfcctrl_test.cantx.can_data, CAN_LEN); /*CAN发送软硬件版本请求*/
        }
        nfcctrl_test.cantx_flag = OK_SENT_OR_RECEIVED; /*发送标志位置位*/
        Record_send_time = RTE_GET_TIMER();            /*记录发送开始时间*/
    }
    /*CAN接受到回复或者超时进入*/
    else if (OK_SENT_OR_RECEIVED == nfcctrl_test.canrx_flag || RTE_TIMEOUT_JUDGMENT(Record_send_time, NFCCTRL_ACCEPT_MAX_DELMS))
    {
        /*接受到回复*/
        if (OK_SENT_OR_RECEIVED == nfcctrl_test.canrx_flag)
        {
            nfcctrl_test.CTRL_ver_comp = NFCCTRL_rtlcd_can_swhd(STATUS_QUALIFIED, NFC_CONTROLLER_TEST, nfcctrl_test.canrx.can_data);
            result = TEST_OK;
        }
        else
        {
            /*超时,全0表示错误*/
            nfcctrl_test.CTRL_ver_comp = NFCCTRL_rtlcd_can_swhd(STATUS_UNQUALIFIED, NFC_CONTROLLER_TEST, candata);
            result = TEST_FAIL;
        }
        nfcctrl_test.N_flag.NFCCTRL_send_data_only = false;
    }
    else
    {
    }
    return result;
}

/**
 * 获取指定GPIO引脚的电平状态
 *
 * @param check_light 指定要检查的GPIO引脚，类型为NFCCTRL_outpin枚举。
 *                    可以选择的引脚包括P1_PE0, P6_PB7, P7_PB4, P17_PB3, P18_PD7。
 * @return 返回GPIO引脚的电平状态，类型为GPIO_PinState。
 *         如果引脚为高电平，则返回GPIO_PIN_SET；
 *         如果引脚为低电平，则返回GPIO_PIN_RESET。
 */
GPIO_PinState NFCCTRL_out_getpin_level(NFCCTRL_outpin check_light)
{
    GPIO_PinState bitstatus;

    // 根据传入的引脚枚举值，获取对应引脚的电平状态
    switch (check_light)
    {
    case P1_PE0:
        bitstatus = RTE_GPIO_PIN_GET_LEVEL(GPIOE, INPUT1_PE0_Pin);
        break;
    case P6_PB7:
        bitstatus = RTE_GPIO_PIN_GET_LEVEL(GPIOB, INPUT2_PB7_Pin);
        break;
    case P7_PB4:
        bitstatus = RTE_GPIO_PIN_GET_LEVEL(GPIOB, INPUT3_PB4_Pin);
        break;
    case P17_PB3:
        bitstatus = RTE_GPIO_PIN_GET_LEVEL(GPIOB, INPUT4_PB3_Pin);
        break;
    case P18_PD7:
        bitstatus = RTE_GPIO_PIN_GET_LEVEL(GPIOD, INPUT5_PD7_Pin);
        break;

    default:
        // 如果传入的引脚枚举值不匹配任何已知引脚，则bitstatus保持为未初始化状态
        break;
    }
    return bitstatus;
}

/*
 * 函数介绍: NFCCTRL的输出测试项检测每个引脚电平
 * 参数:
 * 返回值: {*}
 * 备注:控制器输出，工装输入，检测引脚电平
 * PIN脚序号：P1\P6\P7\P17\P18
 * 母座序号： 17\18\06\19\07
 * MCU引脚：  PD2\PD3\PE11\PE12\PE6
 * MCU引脚：  PE0\PB7\PB4\PB3\PD7
 */
Rt_result NFCCTRL_Check_Pin(NFCCTRL_outpin pin)
{
    Rt_result result = TEST_WAIT;
    NFCCTRL_outpin check_light;
    // 检查所有灯的状态
    for (check_light = P18_PD7; check_light > OUT_MIN; check_light--)
    {
        if (check_light == pin)
        {
            // 当前灯应该是亮的
            if (RTE_PIN_LEVEL_LOW == NFCCTRL_out_getpin_level(check_light))
            {
                result = TEST_OK;
            }
            else
            {
                result = TEST_FAIL;
                break;
            }
        }
        else
        {
            // 其他灯应该是灭的
            if (RTE_PIN_LEVEL_HIGH == NFCCTRL_out_getpin_level(check_light))
            {
                result = TEST_OK;
            }
            else
            {
                result = TEST_FAIL;
                break;
            }
        }
    }
    return result;
}

/*
 * 函数介绍: NFCCTRL的输出测试项检测每个引脚电平
 * 参数:
 * 返回值: {*}
 * 备注:控制器输出，工装输入，检测引脚电平
 * PIN脚序号：P1\P6\P7\P17\P18
 * 母座序号： 17\18\06\19\07
 * MCU引脚：  PD2\PD3\PE11\PE12\PE6
 */
Rt_result NFCCTRL_Out_Pin(NFCCTRL_outpin pin)
{
    Rt_result result = TEST_WAIT;
    static uint32_t Record_send_time = 0; /*记录_发送_时间*/
    /*循环检测，所以只发送一次请求*/
    if (false == nfcctrl_test.N_flag.NFCCTRL_send_data_only)
    {
        nfcctrl_test.cantx.can_id = CAN_FUN_ADDR;
        memcpy(nfcctrl_test.cantx.can_data, can_out_pin, sizeof(can_com_data)); /*填入发送data*/
        nfcctrl_test.cantx.can_data[1] = pin;
        nfcctrl_test.N_flag.NFCCTRL_send_data_only = true;
        RTE_CAN_TRANSMIT(nfcctrl_test.cantx.can_id, nfcctrl_test.cantx.can_data, CAN_LEN); /*CAN发送输出测试*/
        Record_send_time = RTE_GET_TIMER();                                                /*记录发送开始时间*/
    }
    /*等待上锁200MS超时进入*/
    else if (RTE_TIMEOUT_JUDGMENT(Record_send_time, NFCCTRL_ACCEPT_MAX_DELMS))
    {
        result = NFCCTRL_Check_Pin(pin); /*检查引脚电平*/
        nfcctrl_test.N_flag.NFCCTRL_send_data_only = false;
    }
    else
    {
    }
    return result;
}

/*
 * 函数名称：NFCCTRL_Out_test
 * 功能描述：执行NFC控制器输出测试项，检查指定引脚的电平状态。
 * 参数说明：无
 * 返回值：测试结果，可能的值包括TEST_WAIT（测试进行中）、TEST_OK（测试通过）和TEST_FAIL（测试失败）。
 * 备注：该函数检测P1\P6\P7\P17\P18引脚的电平，确保它们处于预期的高电平状态。
 */

Rt_result NFCCTRL_Out_test(void)
{
    Rt_result result = TEST_WAIT; // 初始化测试结果为测试进行中

    if (OUT_MIN == nfcctrl_test.N_flag.outpin_flag)
    {
        nfcctrl_test.N_flag.outpin_flag++; // 由于OUT_MIN不包含引脚，因此标志位加一跳过该状态
    }

    // 调用函数检测当前引脚的电平状态
    result = NFCCTRL_Out_Pin(nfcctrl_test.N_flag.outpin_flag);

    // 如果前一个引脚检测通过，则准备检测下一个引脚，如果检测到最后一个引脚P18且通过，则测试通过
    if (TEST_OK == result)
    {
        result = TEST_WAIT; // 重置结果为测试进行中，准备进行下一个引脚的检测
        if (P18_PD7 == nfcctrl_test.N_flag.outpin_flag)
        {
            result = TEST_OK; // 所有引脚检测通过，设置结果为测试通过
        }
        nfcctrl_test.N_flag.outpin_flag++; // 准备检测下一个引脚
    }
    else if (TEST_FAIL == result) // 如果引脚电平检测失败，则测试整体失败
    {
        result = TEST_FAIL;
    }
    else
    {
        // 如果结果既不是测试通过也不是测试失败，则不做处理
    }

    return result; // 返回测试结果
}

/*
 * 函数介绍: NFCCTRL的输入测试，控制引脚
 * 参数:
 * 返回值: {*}
 * 备注:产品输入，工装输出设置引脚电平
 * PIN脚序号：P4\P9\P10\P12\P16
 * 母座序号： 20\08\10\21\23
 * MCU引脚：  PD6\PD5\PD0\PD4\PC12
 *            反  反  不   反  不
 * PD6,PD5,PD4 反象
 * PD0,PC12    不反象
 * byte2（左转向灯开关输入（0V有效，不输出时悬空））: 0x1（低电平）、0x2（高电平）
 * byte3（应急灯开关（0V有效，不输出时悬空））: 0x1（低电平）、0x2（高电平）
 * byte4（IGN输入（12V有效，不输出悬空））: 0x1（低电平）、0x2（高电平）
 * Byte5（右转向灯开关输入（0V有效，不输出时悬空））: 0x1（低电平）、0x2（高电平）
 * Byte6（制动开关输入（12V有效，不输出时0V））: 0x1（低电平）、0x2（高电平）
 */
void NFCCTRL_Input_set_pin(NFCCTRL_input pin)
{
    if (P4_PD6 == pin)
    { /*左转向灯开关输入（0V有效，不输出时悬空）*/
        nfcctrl_test.N_flag.can_byte = 2;
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT1_PD6_Pin, GPIO_PIN_SET);          // 有效 反象
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT2_PD5_Pin, GPIO_PIN_RESET);        /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, Output9_O_PD0_Pin, GPIO_PIN_RESET);   /*不反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT3_PD4_Pin, GPIO_PIN_RESET);        /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOC, Output10_O_PC12_Pin, GPIO_PIN_RESET); /*不反象*/
    }
    else if (P9_PD5 == pin)
    { /*应急灯开关（0V有效，不输出时悬空）*/
        nfcctrl_test.N_flag.can_byte = 3;
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT1_PD6_Pin, GPIO_PIN_RESET);        /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT2_PD5_Pin, GPIO_PIN_SET);          // 有效 反象
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, Output9_O_PD0_Pin, GPIO_PIN_RESET);   /*不反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT3_PD4_Pin, GPIO_PIN_RESET);        /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOC, Output10_O_PC12_Pin, GPIO_PIN_RESET); /*不反象*/
    }
    else if (P10_PD0 == pin)
    { /*IGN输入（12V有效，不输出悬空）*/
        nfcctrl_test.N_flag.can_byte = 4;
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT1_PD6_Pin, GPIO_PIN_RESET);        /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT2_PD5_Pin, GPIO_PIN_RESET);        /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, Output9_O_PD0_Pin, GPIO_PIN_SET);     // 有效 不反象
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT3_PD4_Pin, GPIO_PIN_RESET);        /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOC, Output10_O_PC12_Pin, GPIO_PIN_RESET); /*不反象*/
    }
    else if (P12_PD4 == pin)
    { /*右转向灯开关输入（0V有效，不输出时悬空）*/
        nfcctrl_test.N_flag.can_byte = 5;
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT1_PD6_Pin, GPIO_PIN_RESET);        /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT2_PD5_Pin, GPIO_PIN_RESET);        /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, Output9_O_PD0_Pin, GPIO_PIN_RESET);   /*不反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT3_PD4_Pin, GPIO_PIN_SET);          // 有效反象
        RTE_GPIO_PIN_SET_LEVEL(GPIOC, Output10_O_PC12_Pin, GPIO_PIN_RESET); /*不反象*/
    }
    else if (P16_PC12 == pin)
    { /*制动开关输入（12V有效，不输出时0V）*/
        nfcctrl_test.N_flag.can_byte = 6;
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT2_PD5_Pin, GPIO_PIN_RESET);      /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT1_PD6_Pin, GPIO_PIN_RESET);      /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, Output9_O_PD0_Pin, GPIO_PIN_RESET); /*不反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT3_PD4_Pin, GPIO_PIN_RESET);      /*反象*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOC, Output10_O_PC12_Pin, GPIO_PIN_SET); // 有效 不反象
    }
    else
    {
    }
}

/*
 * 函数介绍: CAN左转向灯开关输入 报文解析判断
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result canrsp_Left_led(void)
{
    Rt_result result = TEST_WAIT;
    if (RTE_PIN_LEVEL_LOW == nfcctrl_test.canrx.can_data[2] &&
        RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[3] &&
        RTE_PIN_LEVEL_LOW == nfcctrl_test.canrx.can_data[4] &&
        RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[5] &&
        RTE_PIN_LEVEL_LOW == nfcctrl_test.canrx.can_data[6])
    {
        result = TEST_OK;
    }
    else
    {
        result = TEST_FAIL;
    }
    return result;
}

/*
 * 函数介绍: CAN应急灯开关 报文解析判断
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result canrsp_emer_led(void)
{
    Rt_result result = TEST_WAIT;
    if (RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[2] &&
        RTE_PIN_LEVEL_LOW == nfcctrl_test.canrx.can_data[3] &&
        RTE_PIN_LEVEL_LOW == nfcctrl_test.canrx.can_data[4] &&
        RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[5] &&
        RTE_PIN_LEVEL_LOW == nfcctrl_test.canrx.can_data[6])
    {
        result = TEST_OK;
    }
    else
    {
        result = TEST_FAIL;
    }
    return result;
}

/*
 * 函数介绍: CAN IGN输入 报文解析判断
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result canrsp_IGN(void)
{
    Rt_result result = TEST_WAIT;
    if (RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[2] &&
        RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[3] &&
        RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[4] &&
        RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[5] &&
        RTE_PIN_LEVEL_LOW == nfcctrl_test.canrx.can_data[6])
    {
        result = TEST_OK;
    }
    else
    {
        result = TEST_FAIL;
    }
    return result;
}

/*
 * 函数介绍: CAN右转向灯开关输入 报文解析判断
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result canrsp_right_led(void)
{
    Rt_result result = TEST_WAIT;
    if (RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[2] &&
        RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[3] &&
        RTE_PIN_LEVEL_LOW == nfcctrl_test.canrx.can_data[4] &&
        RTE_PIN_LEVEL_LOW == nfcctrl_test.canrx.can_data[5] &&
        RTE_PIN_LEVEL_LOW == nfcctrl_test.canrx.can_data[6])
    {
        result = TEST_OK;
    }
    else
    {
        result = TEST_FAIL;
    }
    return result;
}

/*
 * 函数介绍: CAN制动开关输入 报文解析判断
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result canrsp_brake_led(void)
{
    Rt_result result = TEST_WAIT;
    if (RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[2] &&
        RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[3] &&
        RTE_PIN_LEVEL_LOW == nfcctrl_test.canrx.can_data[4] &&
        RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[5] &&
        RTE_PIN_LEVEL_HIGH == nfcctrl_test.canrx.can_data[6])
    {
        result = TEST_OK;
    }
    else
    {
        result = TEST_FAIL;
    }
    return result;
}

/*
 * 函数介绍: NFCCTRL的输入测试，判断CAN回复是否正确
 * 参数:
 * 返回值: {*}
 * 备注:产品输入，工装输出设置引脚电平
 * PIN脚序号：P4\P9\P10\P12\P16
 * 母座序号： 20\08\10\21\23
 * MCU引脚：  PC4\PC5\PD11\PB0\PA15
 * MCU引脚：  PD6\PD5\PD0\PD4\PC12
 * byte2（左转向灯开关输入（0V有效，不输出时悬空））: 0x1（低电平）、0x2（高电平）
 * byte3（应急灯开关（0V有效，不输出时悬空））: 0x1（低电平）、0x2（高电平）
 * byte4（IGN输入（12V有效，不输出悬空））: 0x1（低电平）、0x2（高电平）
 * Byte5（右转向灯开关输入（0V有效，不输出时悬空））: 0x1（低电平）、0x2（高电平）
 * Byte6（制动开关输入（12V有效，不输出时0V））: 0x1（低电平）、0x2（高电平）
 */
Rt_result NFCCTRL_Input_rsp(void)
{
    Rt_result result = TEST_WAIT;
    if (0x31 == nfcctrl_test.canrx.can_data[0] && 0x01 == nfcctrl_test.canrx.can_data[1])
    {
        /*选择控制得引脚对应得判断CAN报文解析判断函数*/
        if (6 > (nfcctrl_test.N_flag.can_byte - 2))
        {
            result = NFCCTRL_canrsp_List[(nfcctrl_test.N_flag.can_byte - 2)].NFCCTRL_input_canrsp();
        }
    }
    else
    {
        result = TEST_FAIL;
    }
    return result;
}

/*
 * 函数介绍: NFCCTRL的输入测试项检测每个引脚电平
 * 参数:
 * 返回值: {*}
 * 备注:产品输入，工装输出设置引脚电平
 * PIN脚序号：P4\P9\P10\P12\P16
 * 母座序号： 20\08\10\21\23
 * MCU引脚：  PC4\PC5\PD11\PB0\PA15
 * MCU引脚：  PD6\PD5\PD0\PD4\PC12
 */
Rt_result NFCCTRL_Input_Pin(NFCCTRL_input pin)
{
    Rt_result result = TEST_WAIT;
    static uint32_t Record_send_time = 0; /*记录_发送_时间*/
    /*循环检测，所以只发送一次请求*/
    if (false == nfcctrl_test.N_flag.NFCCTRL_send_data_only)
    {
        nfcctrl_test.cantx.can_id = CAN_FUN_ADDR;
        memcpy(nfcctrl_test.cantx.can_data, can_input_pin_rq, sizeof(can_input_pin_rq)); /*填入发送data*/
        nfcctrl_test.N_flag.NFCCTRL_send_data_only = true;
        NFCCTRL_Input_set_pin(pin); /*控制引脚*/
        RTE_HAL_DELAY(20);
        RTE_CAN_TRANSMIT(nfcctrl_test.cantx.can_id, nfcctrl_test.cantx.can_data, CAN_LEN); /*CAN发送输入测试*/
        nfcctrl_test.cantx_flag = OK_SENT_OR_RECEIVED;
        nfcctrl_test.canrx_flag = NO_SENT_OR_RECEIVED;
        Record_send_time = RTE_GET_TIMER(); /*记录发送开始时间*/
    }
    /*接受到数据，或者超时进入*/
    else if (OK_SENT_OR_RECEIVED == nfcctrl_test.canrx_flag ||
             RTE_TIMEOUT_JUDGMENT(Record_send_time, NFCCTRL_ACCEPT_MAX_DELMS))
    {
        if (NO_SENT_OR_RECEIVED == nfcctrl_test.canrx_flag)
        {
            result = TEST_FAIL; /*超时失败*/
        }
        else
        {
            result = NFCCTRL_Input_rsp(); /*判断CAN回复是否正确*/
        }
        nfcctrl_test.N_flag.NFCCTRL_send_data_only = false;
    }
    else
    {
    }
    return result;
}

/*
 * 函数介绍: NFCCTRL输入测试项
 * 参数:
 * 返回值: {*}
 * 备注:产品输入，工装输出设置引脚电平
 * PIN脚序号：P4\P9\P10\P12\P16
 * 母座序号： 20\08\10\21\23
 * MCU引脚：  PC4\PC5\PD11\PB0\PA15
 * MCU引脚：  PD6\PD5\PD0\PD4\PC12
 */
Rt_result NFCCTRL_input_test(void)
{
    Rt_result result = TEST_WAIT;
    /*检测PC4\PC5\PD11\PB0\PA15是否都为高电平*/
    if (IN_MIN == nfcctrl_test.N_flag.inputpin_flag)
    {
        nfcctrl_test.N_flag.inputpin_flag++; /*IN_MIN没有这个引脚*/
    }

    result = NFCCTRL_Input_Pin(nfcctrl_test.N_flag.inputpin_flag);

    if (TEST_OK == result) /*判断所有输入情况*/
    {
        result = TEST_WAIT;
        if (P16_PC12 == nfcctrl_test.N_flag.inputpin_flag)
        {
            result = TEST_OK; /*只有全部测试通过本项测试才通过*/
        }
        nfcctrl_test.N_flag.inputpin_flag++; /*当前阶段通过，切换下阶段*/
    }
    else if (TEST_FAIL == result)
    {
        result = TEST_FAIL; /*一次测试失败本项测试全部失败*/
    }
    else
    {
    }

    return result;
}

/*
 * 函数介绍: NFCCTRL串口通讯测试软硬件版本号
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result NFCCTRL_UART_hard_soft(uint16_t CMD)
{
    Rt_result result = TEST_WAIT;
    static uint32_t Record_send_time = 0; /*记录_发送_时间*/
    /*只发送一次串口请求*/
    if (false == nfcctrl_test.N_flag.NFCCTRL_send_data_only)
    {
        nfcctrl_test.uarttx.sig.CMD = CMD;
        nfcctrl_test.uarttx.sig.DATA = NFCCTRL_REQUEST_DATA;
        nfcctrl_test.N_flag.NFCCTRL_send_data_only = true;
        RTE_EHBL_UART_TRANSMIT(nfcctrl_test.uarttx.sig.CMD, nfcctrl_test.uarttx.sig.DATA); /*串口发送查询软硬件版本请求*/
        nfcctrl_test.uarttx_flag = OK_SENT_OR_RECEIVED;                                    /*发送标志位置位*/
        nfcctrl_test.uartrx_flag = NO_SENT_OR_RECEIVED;                                    /*接受标志位置位*/
        Record_send_time = RTE_GET_TIMER();                                                /*记录发送开始时间*/
    }
    /*串口接受到回复或者超时进入*/
    else if (OK_SENT_OR_RECEIVED == nfcctrl_test.uartrx_flag || RTE_TIMEOUT_JUDGMENT(Record_send_time, NFCCTRL_ACCEPT_MAX_DELMS))
    {
        /*接受到回复*/
        if (OK_SENT_OR_RECEIVED == nfcctrl_test.uartrx_flag)
        {
            result = TEST_OK;
        }
        else
        {
            /*超时*/
            result = TEST_FAIL;
        }
        nfcctrl_test.N_flag.NFCCTRL_send_data_only = false;
    }
    else
    {
    }
    return result;
}

/*
 * 函数介绍: NFCCTRL串口通讯测试
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result NFCCTRL_uartcom_test(void)
{
    Rt_result result = TEST_WAIT; /*返回值*/
    switch (nfcctrl_test.N_flag.v_stage)
    {
    case HARDWARE_VERSION: /*硬件版本阶段*/
        result = NFCCTRL_UART_hard_soft(NFCCTRL_UARTHARD_CMD);
        if (TEST_OK == result)
        {
            /*硬件版本测试通过，开始测试软件版本*/
            nfcctrl_test.N_flag.v_stage = SOFTWARE_VERSION;
        }
        else if (TEST_FAIL == result)
        {
            /*硬件版本测试失败,记录错误，改测软件版本*/
            nfcctrl_test.N_flag.v_stage = SOFTWARE_VERSION;
            nfcctrl_test.N_flag.Error_record += 1;
        }
        else
        {
        }
        result = TEST_WAIT;
        break;

    case SOFTWARE_VERSION: /*软件版本阶段*/
        result = NFCCTRL_UART_hard_soft(NFCCTRL_UARTSOFT_CMD);
        if (TEST_OK == result)
        {
            /*软件版本测试通过，通信测试通过，恢复默认值硬件测试*/
            nfcctrl_test.N_flag.v_stage = HARDWARE_VERSION;
            if (0 < nfcctrl_test.N_flag.Error_record)
            {
                result = TEST_FAIL; /*硬件版本失败，通信测试失败*/
            }
            else
            {
                result = TEST_OK; /*通信测试成功*/
            }
            nfcctrl_test.N_flag.Error_record = 0; /*硬件软件错误计数清零*/
        }
        else if (TEST_OK == result)
        {
            /*软件版本测试失败*/
            nfcctrl_test.N_flag.v_stage = HARDWARE_VERSION;
            result = TEST_FAIL;
            nfcctrl_test.N_flag.Error_record = 0; /*硬件软件错误计数清零*/
        }
        else
        {
        }

        break;
    default:
        break;
    }
    return result;
}

/*
 * 函数介绍: NFCCTRL禁止EHBL电源输出测试
 * 参数:
 * 返回值: {*}
 * 备注:板卡使IGN-I-HL信号为高电平（IG上电）后，
 * 产品内部发送EHBL电源输出命令，此时EHBL电源输出脚EHBL-0-HL（P1引脚）无输出，
 * 板卡检测EHBL-0-HL信号输出的结果，并将结果发给LCD屏显示，后进行下一步测试。
 */
Rt_result NFCCTRL_stopEHBL_powerout(void)
{
    Rt_result result = TEST_WAIT;
    static uint32_t Record_send_time = 0; /*记录_发送_时间*/
    /*只发送一次CAN请求*/
    if (false == nfcctrl_test.N_flag.NFCCTRL_send_data_only)
    {
        nfcctrl_test.N_flag.NFCCTRL_send_data_only = true;
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, Output9_O_PD0_Pin, GPIO_PIN_SET); /*板卡使IGN-I-HL信号为高电平（IG上电）*/
        memcpy(nfcctrl_test.cantx.can_data, can_stop_ehbl, sizeof(can_stop_ehbl));
        nfcctrl_test.cantx.can_id = CAN_FUN_ADDR;
        RTE_CAN_TRANSMIT(nfcctrl_test.cantx.can_id, nfcctrl_test.cantx.can_data, CAN_LEN); /*发送EHBL电源输出命令*/
        Record_send_time = RTE_GET_TIMER();                                                /*记录发送开始时间*/
    }
    /*延时进入查看板卡检测EHBL-0-HL信号输出的结果*/
    else if (RTE_TIMEOUT_JUDGMENT(Record_send_time, NFCCTRL_ACCEPT_MAX_DELMS))
    {
        if (RTE_PIN_LEVEL_HIGH == RTE_GPIO_PIN_GET_LEVEL(GPIOE, INPUT1_PE0_Pin))
        {
            /* 此时EHBL电源输出脚EHBL-0-HL（P1引脚）无输出 */
            result = TEST_OK;
        }
        else
        {
            /*错误*/
            result = TEST_FAIL;
        }
        nfcctrl_test.N_flag.NFCCTRL_send_data_only = false;
    }
    else
    {
    }
    return result;
}


uint32_t extract_float_parts(float current) {
    uint32_t current_lcd = 0;
    current_lcd = (uint32_t)(current * 1000);
    return current_lcd;
}

/*
 * 函数介绍: NFCCTRL测试低功耗AD检测电流是否正常
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result NFCCTRL_check_current(void)
{
    Rt_result result = TEST_WAIT;
    float current_threshold = 1;
    float current;
    float voltage;
    uint32_t current_lcd;
    Curr_produ index;
    /*计算Vout电压*/
    voltage = RTE_ADC2_CHANNEL_V(PC1_ADC2_INP11); //+0.5f
    /*计算静态电流*/
    current = voltage / 5.10f * 2;
    /*如果是读卡器，电流小于0.3mA，则认为低功耗功能正常*/
    index = rt_Curr_produ();
    if (CARD_READER == index)
    {
        current_threshold = 0.3;
    }
    if(CONTROLLER == index)
    {
        current -= 0.03f;
    }
    if (current_threshold >= current)
    {
        /*静态电流小于1mA*/
        result = TEST_OK;
    }
    else
    {
        result = TEST_FAIL;
    }
    nfcctrl_test.N_flag.NFCCTRL_lowpro_del_flag = false;

    /*LCD显示电流大小*/
    current_lcd = extract_float_parts(current);
    RTE_UART7_LCD_SHOW((NFCTestStatus)index,CURRENT_MAGNITUDE,current_lcd);
    return result;
}

/*
 * 函数介绍: NFCCTRL测试低功耗功能是否正常
 * 参数:
 * 返回值: {*}
 * 备注:
 * a. 下电闭锁成功后，等待5S后，进入睡眠
 * b. 先断开Q4，再打开Q1，使电源切换经过5.1R的采样电阻。
 * c.采样电阻将静态电流转换为相应的电压，并经过芯片LTC6102放大500倍后，得到的AD值给单片机判断静态电流是否合格。
 * d. 测试完后，断开Q1，把产品供电电源断开，并将测试结果发给LCD屏显示。
 */
Rt_result NFCCTRL_low_power(void)
{
    Rt_result result = TEST_WAIT;
    static uint32_t Record_send_time = 0; /*记录_发送_时间*/
    /*只发送一次CAN请求*/
    if (false == nfcctrl_test.N_flag.NFCCTRL_send_data_only)
    {
        nfcctrl_test.N_flag.NFCCTRL_send_data_only = true;
        memcpy(nfcctrl_test.cantx.can_data, can_low_power, sizeof(can_low_power));
        nfcctrl_test.cantx.can_id = CAN_FUN_ADDR;
        RTE_CAN_TRANSMIT(nfcctrl_test.cantx.can_id, nfcctrl_test.cantx.can_data, CAN_LEN); /*发送低功耗*/
        if (CONTROLLER == rt_Curr_produ())
        ctrl_gpio_init(0);
        HAL_Delay(1000);
        /*先断开Q4，再打开Q1，使电源切换经过5.1R的采样电阻*/
        RTE_GPIO_PIN_SET_LEVEL(GPIOC, OverCurCtr_O_LL_PC13_Pin, GPIO_PIN_RESET);
        RTE_GPIO_PIN_SET_LEVEL(GPIOE, QuieCur_CTRL_O_PE6_Pin, GPIO_PIN_SET);
        Record_send_time = RTE_GET_TIMER(); /*记录发送开始时间*/
    }
    /*等待5S后，进入睡眠*/
    else if (RTE_TIMEOUT_JUDGMENT(Record_send_time, NFCCTRL_LOW_POWER_DELMS))
    {
        /*采样电阻将静态电流转换为相应的电压，并经过芯片LTC6102放大500倍后，得到的AD值给单片机判断静态电流是否合格。*/
        result = NFCCTRL_check_current();
        if (TEST_WAIT != result)
        {
            if (CONTROLLER == rt_Curr_produ())
            {
                /*测试完后，断开Q1，把产品供电电源断开*/
                RTE_GPIO_PIN_SET_LEVEL(GPIOE, QuieCur_CTRL_O_PE6_Pin, GPIO_PIN_RESET);
                ctrl_gpio_init(1);
            }else{
                /*读卡器低功耗后不关闭电源*/
                RTE_GPIO_PIN_SET_LEVEL(GPIOC, OverCurCtr_O_LL_PC13_Pin, GPIO_PIN_SET);/*产品上电*/
				RTE_GPIO_PIN_SET_LEVEL(GPIOE, Short_CTRL_PE5_Pin, GPIO_PIN_SET);
            }
			nfcctrl_test.CTRL_results = TEST_OK; /*控制器测试完毕*/
            nfcctrl_test.N_flag.NFCCTRL_send_data_only = false;
        }
    }
    else
    {
    }
    return result;
}

/*
 * 函数介绍: 修改NFCCTRL测试阶段
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void Modify_NFCCTRL_testing_phase(NFC_CTRL_stage phase)
{
    nfcctrl_test.stage = phase;
}

/*
 * 函数介绍: 在LCD上显示阶段结果
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void NFCCTRL_Stage_result_LCDshow(Rt_result result, NFC_CTRL_stage stage)
{
    if (TEST_WAIT == result)
    {
        return;
    }
    switch (stage)
    {
    case CAN_COM_TEST:
        RTE_UART7_LCD_SHOW(NFC_CONTROLLER_TEST, CAN_COMMUNICATION, result);
        break;
    case OUTPUT_TEST:
        RTE_UART7_LCD_SHOW(NFC_CONTROLLER_TEST, PRODUCT_OUTPUT_TEST, result);
        break;
    case INP_TEST:
        RTE_UART7_LCD_SHOW(NFC_CONTROLLER_TEST, PRODUCT_INPUT_TEST, result);
        break;
    case UART_COM_TEST:
        RTE_UART7_LCD_SHOW(NFC_CONTROLLER_TEST, SERIAL_COMMUNICATION, result);
        break;
    case PRO_EHBL_TEST:
        RTE_UART7_LCD_SHOW(NFC_CONTROLLER_TEST, EHBL_OUTPUT_DISABLE, result);
        break;
    case LOW_POWER_TEST:
        RTE_UART7_LCD_SHOW(NFC_CONTROLLER_TEST, LOW_POWER_STATE, result);
        break;
    default:
        break;
    }
}

/*
 * 函数介绍: 阶段结果判断
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void NFCCTRL_Stage_result_judgment(Rt_result result, NFC_CTRL_stage stage)
{
    stage += 1;
    NFCCTRL_Stage_result_LCDshow(result, nfcctrl_test.stage);
    if (TEST_OK == result) /*该阶段通讯测试通过*/
    {
        nfcctrl_test.e_sta[nfcctrl_test.stage] = result;
        /*修改EHBL的测试阶段为下一个阶段*/
        Modify_NFCCTRL_testing_phase(stage);
    }
    else if (TEST_FAIL == result)
    {
        nfcctrl_test.e_sta[nfcctrl_test.stage] = result;
        /*修改EHBL的测试阶段为下一个阶段*/
        Modify_NFCCTRL_testing_phase(stage);
    }
    else
    {
    }
}

/*
 * 函数介绍: NFCCTRL测试结果展示
 * 参数:
 * 返回值: {*}
 * 备注:
 * 11.若所有测试项结果OK，测试合格指示绿灯亮，蜂鸣器响1声，
 * LCD屏显示测试合格，并向打标机发送打标信号
 * 反之，测试不合格指示红灯亮，蜂鸣器响3声，
 * LCD屏显示测试不合格。
 * （注： 不合格后进入下一个产品测试时需按一下不良次品盒的开关）
 */
Rt_result NFCCTRL_test_results(void)
{
    uint8_t i = 0;
    Rt_result result = TEST_WAIT; /*测试结果值*/
    /*判断测试流程是否走完*/
    if (TEST_OK == nfcctrl_test.CTRL_results)
    {
        result = TEST_OK;
        nfcctrl_test.CTRL_results = TEST_WAIT; /*置回标志*/
        for (i = 0; i < NFC_CTRL_MAX; i++)
        {
            result |= nfcctrl_test.e_sta[i];
        }
        result |= nfcctrl_test.CTRL_ver_comp;
    }

    if (TEST_OK == result) /*NFCCTRL测试成功*/
    {
        RTE_UART7_LCD_SHOW(NFC_CONTROLLER_TEST, TEST_RESULT, result);
    }
    else if (TEST_FAIL == result) /*NFCCTRL测试失败*/
    {
        RTE_UART7_LCD_SHOW(NFC_CONTROLLER_TEST, TEST_RESULT, result);
    }
    else
    {
    }
    return result;
}

/*
 * 函数介绍: NFC控制器功能测试
 * 参数:
 * 返回值: {*}
 * 备注:
 */
Rt_result NFCCTRL_functional_test(void)
{
    Rt_result result = TEST_WAIT; /*返回值*/
    if (NFC_CTRL_MAX > nfcctrl_test.stage)
    {
        result = NFCCTRL_List[nfcctrl_test.stage].NFCCTRL_test();
    }
    NFCCTRL_Stage_result_judgment(result, nfcctrl_test.stage);
    result = NFCCTRL_test_results();
    return result;
}
